import type { JWT } from "@/types/global-types";
import { ElMessage } from "element-plus";

/**
 * 获取本地存储的JWT
 * @returns 本地JWT
 */
export function getLocalAuthData() {
  // 本地身份认证数据
  const localData = localStorage.getItem("userData");
  return localData;
}

/**
 * 认证检查函数
 * @returns 本地是否有有效用户信息
 */
export function checkAuthStatus() {
  // 1. 检查本地存储中是否有有效的用户信息
  const userData = getLocalAuthData();

  if (!userData) return false;

  try {
    // 解析token和过期时间
    const { expiresTime } = JSON.parse(userData);

    // 2. 检查token是否过期
    if (Date.now() > new Date(expiresTime).getTime()) {
      clearAuthData(); // 清除过期数据
      return false;
    }

    return true;
  } catch (e) {
    console.error("解析用户数据失败", e);
    return false;
  }
}

/**
 * 验证JWT数据有效性
 * @param data 待验证的JWT数据
 * @returns 是否有效
 */
function isValidJWT(data: unknown): data is JWT {
  if (typeof data !== "object" || data === null) return false;

  const jwt = data as JWT;
  return (
    typeof jwt.userId === "string" &&
    ["STUDENT", "TEACHER", "ADMIN"].includes(jwt.userRole) &&
    typeof jwt.token === "string" &&
    (jwt.expiresTime instanceof Date || typeof jwt.expiresTime === "string")
  );
}

/**
 * 保存认证数据到localStorage
 * @param responseData 后端返回的JWT数据
 * @throws {Error} 当输入数据无效时抛出错误
 */
export function saveAuthData(responseData: JWT): void {
  // 验证输入数据有效性
  if (!isValidJWT(responseData)) {
    throw new Error("无效的JWT数据格式");
  }

  // 处理过期时间，统一转换为ISO字符串存储
  const expiresTime =
    responseData.expiresTime instanceof Date
      ? responseData.expiresTime.toISOString()
      : new Date(responseData.expiresTime).toISOString();

  // 构建存储数据
  const authData: JWT = {
    userId: responseData.userId,
    userName: responseData.userName,
    userRole: responseData.userRole,
    token: responseData.token,
    expiresTime,
    loginTime: responseData.loginTime
  };

  try {
    localStorage.setItem("userData", JSON.stringify(authData));
  } catch (error) {
    console.error("存储认证数据失败:", error);
    throw new Error("保存用户信息失败，请检查存储空间");
  }
}

/**
 * 从localStorage获取认证数据
 * @returns 解析后的认证数据或null（无效/不存在时）
 */
export function getAuthData(): JWT | null {
  try {
    const storedData = localStorage.getItem("userData");
    if (!storedData) return null;

    const parsedData = JSON.parse(storedData) as JWT;

    // 验证存储的数据格式
    if (
      typeof parsedData.userId === "string" &&
      ["STUDENT", "TEACHER", "ADMIN"].includes(parsedData.userRole) &&
      typeof parsedData.token === "string" &&
      !isNaN(new Date(parsedData.expiresTime).getTime())
    ) {
      return parsedData;
    }

    // 格式无效时清除数据
    localStorage.removeItem("userData");
    return null;
  } catch (error) {
    console.error("获取认证数据失败:", error);
    localStorage.removeItem("userData");
    return null;
  }
}

/**
 * 清除localStorage中的认证数据
 */
export function clearAuthData(): void {
  if (checkAuthStatus()) localStorage.removeItem("userData");
}

/**
 * 检查认证数据是否已过期
 * @returns 是否过期
 */
export function isAuthExpired(): boolean {
  const authData = getAuthData();
  if (!authData) return true;

  if (new Date(authData.expiresTime) <= new Date()) {
    ElMessage.error("登录信息已过期，请重新登录");
    return true;
  }
  return false;
}

/**
 * 获取本地token
 * @returns token
 */
export function getToken(): string | undefined {
  const token = getAuthData();
  return token?.token;
}

/**
 * 获取本地存储的用户角色
 * @returns 用户角色
 */
export function getUserRole(): string | undefined {
  const token = getAuthData();
  return token?.userRole;
}

/**
 * 获取本地存储的用户名
 * @returns 用户名
 */
export function getUserName(): string | undefined {
  const token = getAuthData();
  return token?.userName;
}

export function getUserId(): string | undefined {
  const token = getAuthData();
  return token?.userId;
}
